
//标识符：就是在java语言中自己可以自定义命名的就是标识符
     /*  *类名
         *方法名
         *接口名
         *常量名
         */
//标识符只能有数字，字母，下划线，美元符号，不能有其他符号。不能以数字开头 
//严格区分大小写
//变量名 方法名 ：首字母小写  后面的大写
//常量名是以字符全部大写，多个单词用下划线隔开

public class Bsf {                                             // bsf就是一个类名
    //*************************************************************************
    /* public static void main(String[] args) {
       System.out.println("3.1415926");
       System.out.println("cxk");
   }  */
   //****************************************************************
       // public static void main(String[] aPAX){
//*************************************************************** */   初等for循环
           /* for(int a=0;a<10;a++)
           {
                System.out.println("1");
           } */
//***************************************************************************** */ 初等输入
         /*  int a;
           float b;
           System.out.println("输入一个数");
           Scanner reader=new Scanner(System.in);//创建Scanner对象对于读取System。in的输入
           a=reader.nextInt();//输入方法就相当于scanf
           System.out.println("再输入一个数让他们相乘");
           b=reader.nextFloat();
           System.out.println("a*b="+a*b);
           System.out.println("a/b="+a/b);*///+是连接符
//********************************************************************************** */ 作业's
           /*int a=2,b=4;
           int x=++a+b++;
           int y=b/a;
           System.out.println("x="+x+"y="+y);*/
//*********************************************************************************** */
           /*int s=5,i=12;
           s+=i++;
           System.out.println("s="+s);*/
//******************************************************************************** */
         /*  int x=0,y=1;
           boolean afact,bfact,cfact,dfact;
           afact='a'==97;
           bfact='a'==100;
           cfact=x<=y;
           dfact=x!=y;
           System.out.println(afact);
           System.out.println(bfact);
           System.out.println(cfact);
           System.out.println(dfact);*/
//*********************************************************************************** */
           /*int x=3;
           boolean j;
           j=x>1&x<5;
           System.out.println(j);*/
//****************************************************************************************** */
        //}
    
//}
   /* public static void main(String[]args){
    Scanner reader=new Scanner(System.in);
      System.out.println("请输入成绩");
      int a;
      a=reader.nextInt();
      if(a>100|a<0)
      {
        System.out.println("输入错误");
      }
      else if(a<=100&a>=90)
      {
        System.out.println("a");
      }
      else if(a<90&a>=75)
      {
        System.out.println("b");
      }
      else if(a<75&a>=60)
      {
        System.out.println("c");
      }
      else
      System.out.println("d");
    

  }  */
  /* public static void main(String[]args){
        Scanner reader=new Scanner(System.in);
      int a;
      System.out.println("请输入数字");
      a=reader.nextInt();
      if(a%3==0)
      {
        if(a%7==0)
        {
          System.out.println(a);
        }
        
      }
    } 
 */
   /*  public static void main(String[]args){
      Scanner reader=new Scanner(System.in);
      int a;
      System.out.println("请输入你想知道的季节");
      a=reader.nextInt();
      if(a>=2&a<=5)
      {
        System.out.println("是春季哦");
      }
      if(a>=6&a<=8)
      {
        System.out.println("是夏天哦");
      }
      if(a>=9&a<=11)
      {
        System.out.println("是秋天哦");
      }
      if(a==12|a<=2)
      {
        System.out.println("是冬天哦");
      }
    }  */
/*方法就是对应着c语言的函数
publi static 返回值 方法名（形式参数列表）{
  方法体  
}
方法名要采用小驼峰的形式。比如maxNun
public static:因为当前的所有的方法 写完后 会在main方法中调用
因为main方法是publi static
返回值：可有可无 具体看业务需求
形参是实参的一份拷贝
*/
  
 /*  public static int maxNun(int num1,int num2,int num3){
    int a= num1>num2?num1:num2;
    return a>num3?a:num3;
  }
    public static void main(String[]args){
      Scanner scanner=new Scanner(System.in);
      int num1=scanner.nextInt();
      int num2=scanner.nextInt();
      int num3=scanner.nextInt();
      int ret=maxNun(num1, num2,num3);
      System.out.println(ret);
    }
    */
    //方法的重载
    //1.方法名相同
    //2.返回值可以不同
    //3.参数列表不同（参数的个数和参数的类型）
    //4.在同一个类当中
    //同一个类中
  /*  public static void main(String[]args){
     Scanner scanner=new Scanner(System.in);
    int s,y;
    s=scanner.nextInt();
    y=scanner.nextInt();
    int Max=sum(s,y);
    double sam=sum(s, y);
   }
   public static int sum(int a,int b){
    return a+b;
   }
   public static double sum(double a,double b){
     return a+b;
   } */
   //递归
   //要调用自身
   //有一个终止条件
   //推导出递归公式
   //横向思考。不要试图展开递归代码
  /*  public static int frc(int n){
     if(n==1){
       return 1;
     }
     return n*frc(n-1);
   }
   public static void main(String[]args){
    Scanner scanner=new Scanner(System.in); 
    int n;
    n=scanner.nextInt();
    int y=frc(n);
    System.out.println(y);
   } */
   /* public static void fac(int n){
     if(n>9){
       fac(n/10); 
     }
     System.out.println(n%10);
      
   }
   public static void main(String[]args){
     Scanner scanner=new Scanner(System.in);
    int n;
    n=scanner.nextInt();
    fac(n);
   } */
   //累加
   /* public static int fac (int n){
     if(n<10){
       return n;
     }
     return n+(n-1);
   }
   public static void main(String[]args){
    Scanner scanner=new Scanner(System.in); 
    int n;
    n=scanner.nextInt();
    int y=fac(n);     
    System.out.println(y);
   } */
   /* public static int mun (int n){
     if(n<10){
      return n;
     }
     return n%10+mun(n/10);
   }
   public static void main(String[]args){
    Scanner scanner=new Scanner(System.in) ;
    int n;
    n=scanner.nextInt();
    int y=mun(n);
    System.out.println(y);
   } */
   //多路递归
  /*  public static int feb(int n){
     if(n==1||n==2){
       return 1;
     }
     return feb(n-1)+feb(n-2);
   }
   public static void main(String[]args){
     Scanner scanner=new Scanner(System.in);
     int n;
     n=scanner.nextInt();
     int y=feb(n);
     System.out.println(y);
   } */
  /*  public static void main(String[]args){
    Scanner scanner=new Scanner(System.in);
    int n,j=1,y,e=1,mun=0;
    y=scanner.nextInt();
    for(n=3;n<=y;n++){
     mun=j+e;
     j=mun;
     e=j;
    }
    System.out.println(mun);
   } */

   //青蛙跳台阶问题

   
 /*   public static int jump(int n){                                  //实现函数
     if(n==1){                                                        //如果只有一个台阶
       return 1;
     }
     else if (n==2){    //如果只有两个台阶               //其实对于青蛙跳台阶，青蛙的跳法只有两种就是跳一个和跳两个
      return 2;                                        //所以有两个if 来让他们实现然后用递归的方式再进行拆解
     }
     else{
       return (n-1)+(n-2);   ///如果是多个台阶
     }
   }
   public static void main(String[]arsg){
    Scanner scanner=new Scanner(System.in); 
    int n;
    n=scanner.nextInt();
    int y=jump(n);
    System.out.println(y);
   } 

//数组
//new  叫做实例化一个对象
  /*  public static void main(String[]arsg){
    int[] a = {1,2,3,4,5,6};
    int[] b=new int[]{};
    int[] c=new int[4];
    int len=a.length;
    for (int i : a) {
      System.out.println(i); 
    }*/
   /*  public static void soup(int arr[]){
      int ls;
      ls=arr[0];
      arr[0]=arr[1];
      arr[1]=ls;

    }
    public static void main(String[]arsg){
      int[] arr={1,2};
      System.out.println(arr[0]+" "+arr[1]);
      soup(arr);
      System.out.println(arr[0]+" "+arr[1]);
      
    } */
    /* public static void main(String[]arsg){
      int[] arr=null;    //这里arr就是一个空
    }*/
   /*  public static int[] coopi(int[] arr){
      int[] fem=new int[arr.length];                  //length是调用了求数组长的方法
      for(int i=0;i<arr.length;i++){
        fem[i]=arr[i];
      }
      return fem;  
    }
    public static void main(String[]arsg){
      int[] arr ={1,2,3,4};
      int[] arr1=coopi(arr);
     System.out.println(Arrays.toString(arr1));      //arrays.tostring 是便利数组的需要调用import java.util.*;

      } */
      // 数组的拷贝有4种方式
      //arrays.copyof
      //结果就1种能用烦死了
      //System.arraycopy                                            
      /* public static void main(String[]arsg){
        int[] arr ={1,2,3,4};
        int[] fas=new int [arr.length];
       int[] fas= Arrays.copyOf(arr,arr.length);
        System.out.println(Arrays.toString(fas)); 
         
      }*/
      /* public static int max(int[] arr){
        int a=0;
        int i;
         for( i=0;i<arr.length;i++){
           if(arr[i]>a)
           a=arr[i];
          }
          return a;
        }
       
      
      public static void main(String[]aStrings) {
        Scanner scanner=new Scanner(System.in);
        int[] arr={0,1,2,3,4,5,6,7,8,9};
       //int a= max(arr);
       int n=scanner.nextInt();
      
       } */
       
  /* public static int fant(int n,int[] arr){
    int max;
    int laft=arr.length-1;
    int reat=0;
    while(laft>=reat){
      max=(laft+reat)/2;
      if(n<arr[max]){
        laft=max-1;
      }
      else if(n>arr[reat]){         //二分查找
        reat=max+1;
      }
      else if(n==arr[max]){
        return max;
      }
    }
    return -1;
  }
  public static void main(String[]asgs){
    Scanner scanner=new Scanner(System.in);
    int[] arr={0,1,2,3,4,5,6,7,8,9};
    int n=scanner.nextInt();
    int f=fant(n,arr);
    System.out.print(f);
  } */
 /*  public static void main(String[]asgs){
    Scanner scanner=new Scanner(System.in);
    int n=scanner.nextInt();
    int[] a={1,2,3,4,5,6,7,8,9};
    System.out.println( Arrays.binarySearch(a, n));                     //着是2分查找的方法
  } */
 /*  public static void main(String[]args){
   int[] array={1,2,3,4,5,6,7,8,9};
   int[] ret = Arrays.copyOfRange(array, 1,5);                          //arrays.copyofrange
  } */
  /* public static void main(String[]args){
    int[] array=new int[10];
    Arrays.fill(array,9);                                               //fill方法填充
    System.out.println(Arrays.toString(array)); 
  }*/
  /* public static void main(String[]asgs){
    int[] array={1,23,4,65,86,89,98,78};
    Arrays.sort(array);                                             //sort 排序方法
    System.out.println(Arrays.toString(array)); 
  } */
 /*  public static int isup(int[] arr){
    int laft=0 ,reat=1;
    int i;
    for( i=0;i<arr.length;i++){
      if(arr[laft] <arr[reat]){
        int j;
        j=reat;
        laft=j;
        reat+=reat;
      }
      else{
        break;
      }
    }
    return i;
  }
  public static void main(String[]asgs){
    int[] arr={1,2,3,4};
    int a=isup(arr);
    System.out.println(a);
    if(a==arr.length-1){
      System.out.println("是升序");
    }
    else{
      System.out.println("不是升序");
    }
  } */

  /*
   *二维数组的定义                                                        
   */
  /* public static void main(String[]asgs){
    int[][] arr={{1,2,3},{4,5,6}};
    for(int i=0;i<2;i++){
      for(int j=0;j<3;j++){
        System.out.print(arr[i][j]+" ");
      }
    }
  } */
  /* public static void main(String[]asgs){
    int[][] arr={{1,2,3},{2,3,1}};
    int[][] arr1=new int[] []{{1,2,3},{1,2,3}};
    int[][] arr2=new int[2] [3];
  } */
 /*  public static void main(String[]asgs){
    int[][] arr={{1,2,3},{2,3,1}};
    for(int i=0;i<arr.length;i++)                       //在这个数组中arr。length是数组的行数     arr[0].lengtg是列数
    {
      for(int j=0;j<arr[i].length;j++)
      {
        System.out.print(arr[i][j]);
      }
    }
  } */
 /*  public static void main(String[]asgs){
    int[][] arr={{1,2,3},{2,3,1}};
    System.out.println(Arrays.deepToString(arr));                           //这个方法是深度打印的方法
  } */
 /*  public static void main(String[]asgs){
    int[][] arr={{1,2,3},{2,3,1}};
    for (int[] is : arr) 
    {
      for (int x :is ) {
        System.out.println(x);
      } 
    }
  } */
  /* public static void main(String[]asgs){
    int[][] arr=new int[3][];
    arr[0]=new int[] {1,2,3};
    arr[1]=new int[] {3,4};
    System.out.println(Arrays.deepToString(arr)); 

  }*/
  /* public static int fant(int[] arr){
    int frc=0;
    for(int i=0;i<arr.length;i++){
      frc= frc^arr[i];
    }
    return frc;
  }
  public static void main(String[]asgs){
    int[] arr={1,1,1,1,2,3,2,3,3,5,5};
    int i=fant(arr);
    System.out.print(i);
  } */
 /*  public static void feat(int[] arr){
    int eor=0;
    for(int i=0;i<arr.length;i++){
      eor^=arr[i];                                                          //按位异或^
    }                                                                       //^异或运算符是有交换律的
    int righOne=eor&(~eor+1);                                               //取到最左侧的1
    int onLyOne=0;
    for (int j : arr) {
      
    
      if((j&righOne)==1){
        onLyOne^=j;
      }
    }
    System.out.println(onLyOne+" "+(onLyOne^eor));
  }
  public static void main(String[]asgs){
    int[] arr={1,1,3,3,3,5,5,6,6,6,6,8,8,8};
    feat(arr);
  
  } */
 /*  public static void main(String[]asgs){
    int i,j;
    for(i=1;i<10;i++){
      for(j=1;j<=i;j++){
        System.out.print(j+"x"+i+"="+j*i);
      }
      System.out.println("");
    } 
  }*/
  /* public static void swap(int[] arr,int j, int i){
    int li;
    li=arr[j];
    arr[j]=arr[i];
    arr[i]=li;
  }
  public static void  InsertionSort(int[] arr){
    for(int i=1;i<arr.length;i++){
      for(int j=i-1;j>=0&&arr[j]>arr[j-1];j--){
       swap(arr,j,j+1);
      }
    }
  }
  public static void main(String[]asgs){
    int[] arr={3,5,6,1,8,4,2,3};
    InsertionSort(arr);
    for(int i=0;i<arr.length;i++){
      System.out.println(arr[i]);
    }
  } */
  /* public static void main(String[]asgs){                                  //顺序表
    int j=1,i=1,sum=0,cj=1;
    for(i=1;i<=5;i++){
      for(j=1;j<=i;j++){
        cj=cj*j;
      }
      sum+=cj;
    }
  }*/
  public static void main(String[]asgs){
    float j=(float) 3.4;
  }
} 
   
   


